Un oyente en JNDI est� representado por el interface NamingListener.
Este es el interface ra�z para los objetos que manejan eventos generados por el JNDI. Normalmente, un objeto implementa un subinterface de NamingListener en vez de implementarlo directamente.
El paquete javax.naming.event contiene dos subinterfaces de NamingListener: ObjectChangeListener y NamespaceChangeListener.
El paquete javax.naming.ldap contiene un subinterface: UnsolicitedNotificationListener.
Este subinterface se explica en la secci�n Notificaciones LDAP no solicitadas.
�Manejar Errores
El inteface NamingListener no s�lo sirve como interface ra�z sino que tambi�n especifica como se le notifican los errores a un oyente registrado. Define un s�lo m�todo namingExceptionThrown().
El proveedor de servicios llama a este m�todo cuando ocurre un error mientras esta recolectando datos para generar eventos que el oyente est� esperando. Por ejemplo, el servidor podr�a haber ca�do offline y no recoger m�s datos en esta parte del directorio. Cuando esto ocurre, el proveedor de servicio des-registra al oyente y llama a namingExceptionThrown() sobre �l para notificarle el problema. Esto permite tomar acciones, como notificar al usuario de la aplicaci�n que debido a un problema no han ocurrido m�s eventos.
Puedes ir a la secci�n Registro de Oyentes para ver m�s detalles sobre c�mo manejar errores cuando se registran oyentes.
�Manejar Cambios en el Espacio de Nombres
NamespaceChangeListener maneja eventos que afectan al espacio de nombres, incluyendo la adici�n, eliminaci�n y renombrado de un objeto. Un objeto que implemente este interface debe proporcionar definiciones para los tres m�todos declarados en el interface, as� como para namingExceptionThrown() (del interface NamingListener).
Aqu� tenemos un ejemplo de un NamespaceChangeListener.
public class SampleNCListener implements NamespaceChangeListener {
private String id;
public SampleNCListener(String id) {
this.id = id;
}
public void objectAdded(NamingEvent evt) {
System.out.println(id + ">>> added: " + evt.getNewBinding());
}
public void objectRemoved(NamingEvent evt) {
System.out.println(id + ">>> removed: " + evt.getOldBinding());
}
public void objectRenamed(NamingEvent evt) {
System.out.println(id + ">>> renamed: " + evt.getNewBinding() + " from " +
evt.getOldBinding());
}
public void namingExceptionThrown(NamingExceptionEvent evt) {
System.out.println(id + ">>> SampleNCListener got an exception");
evt.getException().printStackTrace();
}
}
Cuando se ha a�adido un objeto, getOldBinding() siempre devolver� null porque no era el espacio de nombres anterior al que est� siendo a�adido. Cuando se ha eliminado unobjeto, getNewBinding() siempre ser� null porque no estar� en el espacio de nombres despu�s de haber sido eliminado. Podemos encontrar m�s detalles sobre las uniones nuevas y viejas en la secci�n Eventos de Nombrado.
�Manejar de Cambios en Objetos
ObjectChangeListener maneja eventos que afectan al contenido de un objeto, por ejemplo, si una uni�n de un objeto ha sido reemplazada por otra o uno de los atributos del objeto se ha eliminado o reemplazado.
Un objeto que implemente el interface ObjectChangeListener debe proporcionar definiciones para objectChanged() y para namingExceptionThrown() (desde el interface NamingListener).
Aqu� tenemos un ejemplo de un ObjectChangeListener.
public class SampleOCListener implements ObjectChangeListener {
private String id;
public SampleOCListener(String id) {
this.id = id;
}
public void objectChanged(NamingEvent evt) {
System.out.println(id + ">>> object changed: " + evt.getNewBinding() +
" from " + evt.getOldBinding());
}
public void namingExceptionThrown(NamingExceptionEvent evt) {
System.out.println(id + ">>> SampleOCListener got an exception");
evt.getException().printStackTrace();
}
}
Aunque este ejemplo muestra las uniones nueva y vieja de un objeto modificado, alguna parte de toda esta informaci�n podr�a no estar disponible si no la suministra el proveedor de servicios o el servidor de nombres/directorios.
Puedes encontrar m�s detalles sobre las nuevas y viejas uniones en la secci�n Eventos de Nombrado.
Observa que eliminar un objeto es un cambio en el espacio de nombres, no un cambio en el contenido del objeto. Una aplicaci�n interesada en las dos cosas deber�a usar un oyente que implemente NamespaceChangeListener y ObjectChangeListener, como se describe ahora.
�Manejar m�s de un tipo de Cambios
Si estamos interesados en los cambios en el espacio de nombres y en el contenido del objeto, deber�amos definir un oyente que implemente ambos interfaces. De esta forma, el proveedor de servicios podr�a optimizar los recursos usados para el registro y recolecci�n de datos sobre ambos tipos de cambios con una s�la petici�n al servidor. Tambi�n reduce el n�mero de oyentes que el proveedor debe manejar y el tama�o del c�digo de nuestra aplicaci�n.
Aqu� tenemos un ejemplo de un oyente que implementa NamespaceChangeListener y ObjectChangeListener.
public class SampleListener
implements NamespaceChangeListener, ObjectChangeListener {
private String id;
public SampleListener(String id) {
this.id = id;
}
public void objectAdded(NamingEvent evt) {
System.out.println(id + ">>> added: " + evt.getNewBinding());
}
public void objectRemoved(NamingEvent evt) {
System.out.println(id + ">>> removed: " + evt.getOldBinding());
}
public void objectRenamed(NamingEvent evt) {
System.out.println(id + ">>> renamed: " + evt.getNewBinding() + " from " +
evt.getOldBinding());
}
public void objectChanged(NamingEvent evt) {
System.out.println(id + ">>> object changed: " + evt.getNewBinding() +
" from " + evt.getOldBinding());
}
public void namingExceptionThrown(NamingExceptionEvent evt) {
System.out.println(id + ">>> SampleNCListener got an exception");
evt.getException().printStackTrace();
}
}